(function() {
  'use strict';

  // 等待页面加载完成
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', init);
  } else {
    init();
  }

  function init() {
    // 检查 ConsoleFormatter 是否可用
    if (!window.ConsoleFormatter) {
      console.warn('ConsoleFormatter 未就绪，确保已加载扩展且在主世界注册。');
      return;
    }

    // 新的测试案例集合
    const testCases = {
      // 1. 基本数据类型展示
      primitives: {
        string: "Hello World",
        number: 42,
        boolean: true,
        null: null,
        undefined: undefined,
        date: new Date(),
        regex: /test/gi
      },
      
      // 2. 层级深度测试
      deepNested: {
        level1: {
          level2: {
            level3: {
              level4: {
                level5: {
                  deepValue: "这是第5层",
                  deepArray: [1, 2, 3, { nested: true }]
                }
              }
            }
          }
        }
      },
      
      // 3. 数组类型测试
      arrays: {
        empty: [],
        primitives: [1, 2, 3, "a", "b", "c"],
        objects: [
          { id: 1, name: "项目1", active: true },
          { id: 2, name: "项目2", active: false },
          { id: 3, name: "项目3", active: true }
        ],
        mixed: [1, "string", true, null, { nested: "object" }],
        large: Array.from({ length: 15 }, (_, i) => ({ 
          id: i + 1, 
          name: `Item ${i + 1}`, 
          value: Math.random() * 100,
          active: i % 2 === 0 
        }))
      },
      
      // 4. 复杂业务对象
      businessData: {
        user: {
          id: 12345,
          name: "张三",
          email: "zhangsan@example.com",
          profile: {
            age: 30,
            city: "北京",
            hobbies: ["编程", "阅读", "旅行"],
            settings: {
              theme: "dark",
              notifications: true,
              language: "zh-CN"
            }
          },
          permissions: ["read", "write", "admin"],
          lastLogin: new Date(),
          isActive: true
        },
        config: {
          whiteList: [1760168792990538, 1760168792990539, 1760168792990540],
          description: "企业ID白名单",
          enabled: true,
          rules: {
            maxAttempts: 3,
            timeout: 30000,
            retryInterval: 1000
          }
        },
        metadata: {
          version: "1.0.0",
          timestamp: Date.now(),
          features: ["auto-format", "custom-styles", "deep-preview"],
          build: {
            number: 1234,
            date: "2025-01-20",
            branch: "main"
          }
        }
      },
      
      // 5. 特殊字符和边界情况
      edgeCases: {
        emptyString: "",
        longString: "这是一个很长的字符串，用来测试长文本的显示效果，看看是否会正确截断或者换行显示",
        specialChars: "特殊字符: !@#$%^&*()_+-=[]{}|;':\",./<>?",
        unicode: "Unicode测试: 🎨✨🚀💻🔥",
        numbers: {
          integer: 42,
          decimal: 3.14159,
          negative: -100,
          scientific: 1.23e10,
          zero: 0,
          maxSafe: Number.MAX_SAFE_INTEGER
        }
      }
    };

    // 主要测试函数
    function doLog() {
      console.log('=== Console Formatter 功能测试 ===');
      
      // 基本数据类型测试
      console.log('1. 基本数据类型:', testCases.primitives);
      
      // 层级深度测试
      console.log('2. 层级深度测试:', testCases.deepNested);
      
      // 数组类型测试
      console.log('3. 数组类型测试:', testCases.arrays);
      
      // 复杂业务对象测试
      console.log('4. 复杂业务对象:', testCases.businessData);
      
      // 边界情况测试
      console.log('5. 边界情况测试:', testCases.edgeCases);
      
      // 多参数测试
      console.log('6. 多参数测试:', "字符串", 123, true, null, testCases.businessData.user);
      
      console.log('=== 测试完成 ===');
    }


    // 设置层级深度
    function setDepth(depth) {
      if (window.ConsoleFormatter && typeof window.ConsoleFormatter.setHeaderDepth === 'function') {
        window.ConsoleFormatter.setHeaderDepth(depth);
      } else {
        console.log('ConsoleFormatter 未就绪，无法设置层级');
      }
    }

    // 刷新自动格式化状态
    function refreshAutoStatus() {
      var el = document.getElementById('auto-status');
      if (!el) return;
      if (window.ConsoleFormatter && typeof window.ConsoleFormatter.isAutoEnabled === 'function') {
        el.textContent = '自动格式化：' + (window.ConsoleFormatter.isAutoEnabled() ? '已开启' : '已关闭');
      } else {
        el.textContent = '自动格式化：未知（formatter 未就绪）';
      }
    }

    // 测试复制功能
    function testCopyFunction() {
      console.log('=== 复制功能测试 ===');
      
      // 创建一个深度嵌套的测试对象
      const testObj = {
        level1: {
          level2: {
            level3: {
              level4: {
                level5: {
                  deepValue: "这是第5层的数据",
                  deepArray: [1, 2, 3, { nested: true }]
                }
              }
            }
          }
        },
        array: [1, 2, 3, { nested: "array item" }],
        simple: "简单值"
      };
      
      console.log('测试对象（当前层级设置：' + window.ConsoleFormatter.getHeaderDepth() + '）:', testObj);
      console.log('请右键复制上面的对象，检查复制的内容是否与当前层级设置一致');
      console.log('如果复制的内容包含了超过当前层级设置的深层数据，说明复制功能需要修复');
      
      // 显示当前设置
      console.log('当前设置：');
      console.log('- 预览层级：', window.ConsoleFormatter.getHeaderDepth());
      console.log('- 自动格式化：', window.ConsoleFormatter.isAutoEnabled());
    }

    // 测试长度限制功能
    function testLengthLimit() {
      console.log('=== 长度限制测试 ===');
      
      // 创建一个超长字符串的测试对象
      const longString = 'A'.repeat(3000); // 3000个字符的字符串
      const testObj = {
        shortData: "短数据",
        longString: longString,
        nested: {
          anotherLongString: 'B'.repeat(2000), // 2000个字符的字符串
          normalData: "正常数据"
        },
        array: [
          "数组项1",
          'C'.repeat(1500), // 1500个字符的字符串
          "数组项3"
        ]
      };
      
      console.log('测试对象（当前长度限制：' + window.ConsoleFormatter.getMaxLength() + ' 字符）:', testObj);
      console.log('如果上面的对象显示被截断并带有省略号(...)，说明长度限制功能正常工作');
      
      // 显示当前设置
      console.log('当前设置：');
      console.log('- 长度限制：', window.ConsoleFormatter.getMaxLength(), '字符');
      console.log('- 预览层级：', window.ConsoleFormatter.getHeaderDepth());
      console.log('- 自动格式化：', window.ConsoleFormatter.isAutoEnabled());
      
      // 测试不同长度限制
      console.log('\n--- 测试不同长度限制 ---');
      console.log('设置长度限制为 500 字符：');
      window.ConsoleFormatter.setMaxLength(500);
      console.log('短限制测试对象:', testObj);
      
      console.log('\n设置长度限制为 5000 字符：');
      window.ConsoleFormatter.setMaxLength(5000);
      console.log('长限制测试对象:', testObj);
      
      // 恢复默认设置
      window.ConsoleFormatter.setMaxLength(2048);
    }

    // 测试值宽度限制功能
    function testValueWidthLimit() {
      console.log('=== 值宽度限制测试 ===');
      
      // 创建包含长字符串的测试对象
      const longString = 'A'.repeat(200); // 200个字符的字符串
      const testObj = {
        shortString: "短字符串",
        longString: longString,
        number: 123456789,
        nested: {
          anotherLongString: 'B'.repeat(150), // 150个字符的字符串
          normalString: "正常字符串"
        },
        array: [
          "数组项1",
          'C'.repeat(120), // 120个字符的字符串
          "数组项3"
        ]
      };
      
      console.log('测试对象（当前值宽度限制：' + window.ConsoleFormatter.getMaxValueWidth() + ' 字符）:', testObj);
      console.log('如果上面的长字符串被截断并显示省略号(...)，说明值宽度限制功能正常工作');
      
      // 显示当前设置
      console.log('当前设置：');
      console.log('- 值宽度限制：', window.ConsoleFormatter.getMaxValueWidth(), '字符');
      console.log('- 内容长度限制：', window.ConsoleFormatter.getMaxLength(), '字符');
      console.log('- 预览层级：', window.ConsoleFormatter.getHeaderDepth());
      console.log('- 自动格式化：', window.ConsoleFormatter.isAutoEnabled());
      
      // 测试不同值宽度限制
      console.log('\n--- 测试不同值宽度限制 ---');
      console.log('设置值宽度限制为 50 字符：');
      window.ConsoleFormatter.setMaxValueWidth(50);
      console.log('短限制测试对象:', testObj);
      
      console.log('\n设置值宽度限制为 200 字符：');
      window.ConsoleFormatter.setMaxValueWidth(200);
      console.log('长限制测试对象:', testObj);
      
      // 恢复默认设置
      window.ConsoleFormatter.setMaxValueWidth(80);
    }

    // 绑定事件
    window.addEventListener('DOMContentLoaded', function () {
      document.getElementById('btn-log').addEventListener('click', doLog);
      document.getElementById('btn-copy-test').addEventListener('click', testCopyFunction);
      document.getElementById('btn-length-test').addEventListener('click', testLengthLimit);
      document.getElementById('btn-primitive-test').addEventListener('click', testValueWidthLimit);
      document.getElementById('btn-depth2').addEventListener('click', function () { setDepth(2); });
      document.getElementById('btn-depth3').addEventListener('click', function () { setDepth(3); });
      document.getElementById('btn-depth4').addEventListener('click', function () { setDepth(4); });
      document.getElementById('btn-auto-on').addEventListener('click', function () {
        if (window.ConsoleFormatter && typeof window.ConsoleFormatter.enableAuto === 'function') {
          window.ConsoleFormatter.enableAuto(true);
          refreshAutoStatus();
          doLog();
        }
      });
      document.getElementById('btn-auto-off').addEventListener('click', function () {
        if (window.ConsoleFormatter && typeof window.ConsoleFormatter.enableAuto === 'function') {
          window.ConsoleFormatter.enableAuto(false);
          refreshAutoStatus();
          doLog();
        }
      });

      // 初始日志和状态
      doLog();
      refreshAutoStatus();
    });
  }
})();
